#pragma once
#include "fields.hpp"
#include <memory>
#include <string>
#include <functional>

//抽象类多态设计
//通过基类指针调用了子类重写的虚函数，允许Dispatcher类只依赖于抽象接口BaseConnection，而不需要知道具体的连接实现细节，符合依赖倒置原则

namespace bitrpc{
    //信息类
    class BaseMessage{
        public:
            using ptr = std::shared_ptr<BaseMessage>;
            virtual ~BaseMessage(){} 

            virtual void setId(const std::string id){
                _rid = id;
            }
            virtual std::string rid() {
                return _rid;
            }

            virtual void setMtype(bitrpc::MType mtype){
                _mtype = mtype;
            }
            
            virtual MType mtype(){
                return _mtype;
            }
            
            virtual std::string serialize() = 0;                   // 将消息序列化为字符串
            virtual bool unserialize(const std::string &msg) = 0;  //从字符串反序列化消息
            virtual bool check() = 0;                    
        private:
            MType _mtype;        // 消息类型
            std::string _rid;    // 消息ID
    };

    //缓冲区类 - 用于获取"缓冲区数据"
    class BaseBuffer{
        public:
            using ptr = std::shared_ptr<BaseBuffer>;

            virtual size_t readableSize() = 0;                     // 获取可读数据大小
            virtual int32_t peekInt32() = 0;                       // 查看一个32位整数但不移动读指针
            virtual void retrieveInt32() = 0;                      // 跳过一个32位整数
            virtual int32_t readInt32() = 0;                       // 读取一个32位整数并移动读指针
            virtual std::string retrieveAsString(size_t len) = 0;  // 提取指定长度的字符串
    };

    //协议类 - 处理消息的编解码
    class BaseProtocol {
        public:
            using ptr = std::shared_ptr<BaseProtocol>;

            virtual bool canProcessed(const BaseBuffer::ptr &buf) = 0;                          
            virtual bool onMessage(const BaseBuffer::ptr &buf, BaseMessage::ptr &msg) = 0;      
            virtual std::string serialize(const BaseMessage::ptr *msg) = 0;                     
    };

    //连接类 - 底层网络连接
    class BaseConnection{
        public:
            using ptr = std::shared_ptr<BaseConnection>;

            virtual void send(const BaseMessage::ptr &msg) = 0;  // 发送消息
            virtual void shutdown() = 0;                         // 断开连接
            virtual bool connected() = 0;                        // 检查连接状态
    };

    //设置"回调函数"参数部分采用"BaseConnection"用于连接管理名称

    // 1.连接建立时的回调函数类型
    using ConnectionCallback  = std::function<void(const BaseConnection::ptr&)>;
    // 2.连接关闭时的回调函数类型
    using CloseCallback = std::function<void(const BaseConnection::ptr&)>;
    // 3.收到消息时的回调函数类型
    using MessageCallback = std::function<void(const BaseConnection::ptr&, BaseMessage::ptr&)>;

    //服务端管理 连接相关的回调函数 提供对应接口
    class BaseServer{
        public:
             using ptr = std::shared_ptr<BaseServer>;
             
             virtual void setConnectionCallback(const ConnectionCallback& cb) {
                _cb_connection = cb;
             }
            // 设置连接关闭回调
            virtual void setCloseCallback(const CloseCallback& cb) {
                _cb_close = cb;
            }
            // 设置消息接收回调
            virtual void setMessageCallback(const MessageCallback& cb) {
                _cb_message = cb;
            }
            virtual void start() = 0;  

        protected:
             ConnectionCallback _cb_connection;     // 连接建立回调函数
             CloseCallback _cb_close;               // 连接关闭回调函数
             MessageCallback _cb_message;           // 消息接收回调函数
    };
    
    //客户端管理 连接相关的回调函数 提供对应接口
    class BaseClient{
        public:
            using ptr = std::shared_ptr<BaseClient>;

            // 设置连接建立回调
            virtual void setConnectionCallback(const ConnectionCallback& cb) {
                _cb_connection = cb;
            }
            // 设置连接关闭回调
            virtual void setCloseCallback(const CloseCallback& cb) 
            {
                _cb_close = cb;
            }
            // 设置消息接收回调
            virtual void setMessageCallback(const MessageCallback& cb) 
            {
                _cb_message = cb;
            }

            //客户端需要添加一些接口
            virtual void connect() = 0;                         // 建立连接
            virtual void shutdown() = 0;                        // 断开连接
            virtual void send(const BaseMessage::ptr& ) = 0;    // 发送消息
            virtual bool connected() = 0;                       // 检查连接状态

        protected:
            ConnectionCallback _cb_connection;                  // 连接建立回调函数
            CloseCallback _cb_close;                            // 连接关闭回调函数
            MessageCallback _cb_message;                        // 消息接收回调函数
    };
};
//客户端和服务端虽然角色不同，但在网络通信的基本模式上是相似的，都需要处理连接建立、连接断开和消息接收这三类基本事件。通过回调函数机制，可以灵活地处理这些事件，同时保持代码的解耦和可维护性。




